package com.janko.springbootbase.juc;

import java.util.concurrent.TimeUnit;

/**
 * @Description 类文件说明
 * @Author nieyankang
 * @Version 1.0
 * @date {date} {time}
 */
public class Test_Juc {

    /**
     * TODO: 以下几个方法要完成实现
     * 01A线程正在执行一个对象中的同步方法，B线程是否可以同时执行同一个对象中的非同步方法？
     * 02同上，B线程是否可以同时执行同一个对象中的另一个同步方法？
     * 03 两个线程，加锁互斥，如果其中一个线程抛出异常（会释放锁吗），另一个线程能拿到锁吗
     * 04 volatile和synchronized区别？
     * 05 写一个程序，证明AtomXXX类比synchronized更高效
     * 06 AtomXXX类可以保证可见性吗？请写一个程序来证明
     * 07 写一个程序证明AtomXXX类的多个方法并不构成原子性
     * 08 写一个程序模拟死锁
     * 09 写一个程序，在main线程中启动100个线程，100个线程完成后，主线程打印“完成”，使用join()和countdownlatch都可以完成，请比较异同
     * 10 两个线程 交互打印A、B两个字母
     */
    public static void main(String[] args) {
        testTwoWord10();
//        test03();
//        test04();
    }

    /**
     * 线程A,B 交替打印A/B 等待唤醒机制
     */
    static  void testTwoWord10(){
    }

    /**
     * 两个线程，加锁互斥，如果其中一个线程抛出异常（会释放锁吗），另一个线程能拿到锁吗
     */
    static void test03() {
        Object o = new Object();
        new Thread(() -> {
            synchronized (o) {
                int c = 0;
                while (true) {
                    try {
                        System.out.println(Thread.currentThread().getName());
                        TimeUnit.MILLISECONDS.sleep(1000);
                    } catch (InterruptedException exception) {
                        exception.printStackTrace();
                    }
                    c++;
                    if (c == 10)
                        c = c / 0;
                }
            }
        }, "t1").start();

        new Thread(() -> {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o) {
                while (true) {
                    System.out.println(Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "t2").start();
    }

    /**
     * volatile和synchronized区别？
     */
    static void test04(){
        System.out.println("volatile和synchronized区别？\n" +
                "区别1：volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住.\n " +
                "区别2：volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞\n" +
                "区别3:volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性\n");
        System.out.println("volatile能做的事情，Synchronized都能做，例如：可以修饰变量、修饰的变量保证它的值是能被线程发现(volatile是保证该线程的数据被主线程发现，而Synchronized是会造成阻塞等它用完该变量之后其他线程再使用)\n " +
                "volatile标记的变量不会被编译器优化、Synchronized标记的变量是可以被编译器优化");
    }
}
